﻿package frEngine.animateControler.colorControler
{
    import __AS3__.vec.*;
    import baseEngine.core.*;
    import flash.geom.*;
    import frEngine.animateControler.*;
    import frEngine.animateControler.keyframe.*;
    import frEngine.math.*;
    import frEngine.shader.*;

    public class ColorControler extends MeshAnimateBase
    {
        static const vectorR:Vector3D = new Vector3D();
        static const vectorG:Vector3D = new Vector3D();
        static const vectorB:Vector3D = new Vector3D();
        private static const defaultOffsetValue:ColorKeyFrame = new ColorKeyFrame(0, 0, null);

        public function ColorControler()
        {
            return;
        }// end function

        override public function dispose(param1:Boolean = true) : void
        {
            var _loc_2:MaterialParams = null;
            if (targetMesh)
            {
                _loc_2 = targetMesh.material.materialParams;
                _loc_2.colorBase = _loc_2.colorBase;
            }
            super.dispose();
            return;
        }// end function

        override protected function setTargetProperty(param1) : void
        {
            var _loc_2:ColorKeyFrame = null;
            var _loc_3:MaterialParams = null;
            var _loc_4:Vector.<Number> = null;
            if (targetMesh)
            {
                _loc_2 = param1 as ColorKeyFrame;
                _loc_3 = targetMesh.material.materialParams;
                _loc_4 = _loc_3.colorOffsetValue;
                _loc_4[0] = _loc_2.colorOffsetR;
                _loc_4[1] = _loc_2.colorOffsetG;
                _loc_4[2] = _loc_2.colorOffsetB;
            }
            return;
        }// end function

        override public function get type() : int
        {
            return AnimateControlerType.colorAnimateControler;
        }// end function

        override protected function getBaseValue(param1:Pivot3D) : Object
        {
            return defaultOffsetValue;
        }// end function

        override public function offsetKeyFrame(param1:Object, param2:int, param3:int, param4:String) : void
        {
            return;
        }// end function

        override protected function calculateFrameValue(param1:int) : void
        {
            var _loc_4:ColorKeyFrame = null;
            var _loc_5:int = 0;
            var _loc_6:int = 0;
            var _loc_7:Boolean = false;
            var _loc_8:int = 0;
            var _loc_9:int = 0;
            var _loc_10:ColorKeyFrame = null;
            var _loc_11:uint = 0;
            var _loc_12:Number = NaN;
            var _loc_13:Number = NaN;
            var _loc_14:Number = NaN;
            var _loc_15:Number = NaN;
            var _loc_16:Number = NaN;
            var _loc_17:Number = NaN;
            var _loc_2:* = getTimeIndex(param1, _keyframes);
            var _loc_3:* = _keyframes[_loc_2];
            if (_loc_3.frame == param1 || _loc_2 == (_keyframes.length - 1))
            {
                _cache[param1] = _loc_3;
            }
            else
            {
                _loc_4 = _keyframes[(_loc_2 + 1)];
                _loc_5 = _loc_3.frame;
                _loc_6 = _loc_4.frame;
                _loc_7 = _loc_3.bezierVo.isLineTween || _loc_4.bezierVo.isLineTween;
                _loc_8 = param1 + 2 + int(Math.random() * 30);
                var _loc_18:* = _loc_6;
                _loc_8 = _loc_6;
                if (_loc_7)
                {
                    _loc_11 = _loc_6 - _loc_5;
                    _loc_12 = (_loc_4.colorOffsetR - _loc_3.colorOffsetR) / _loc_11;
                    _loc_13 = (_loc_4.colorOffsetG - _loc_3.colorOffsetG) / _loc_11;
                    _loc_14 = (_loc_4.colorOffsetB - _loc_3.colorOffsetB) / _loc_11;
                    _loc_9 = param1;
                    while (_loc_9 < _loc_8)
                    {
                        
                        if (!_cache[_loc_9])
                        {
                            _loc_10 = new ColorKeyFrame(_loc_9, -1, null);
                            _loc_10.colorOffsetR = _loc_3.colorOffsetR + (_loc_9 - _loc_5) * _loc_12;
                            _loc_10.colorOffsetG = _loc_3.colorOffsetG + (_loc_9 - _loc_5) * _loc_13;
                            _loc_10.colorOffsetB = _loc_3.colorOffsetB + (_loc_9 - _loc_5) * _loc_14;
                            _cache[_loc_9] = _loc_10;
                        }
                        _loc_9++;
                    }
                }
                else
                {
                    NumberUtil.getBezierData(_loc_5, _loc_6, _loc_5 + _loc_3.bezierVo.RX, _loc_6 + _loc_4.bezierVo.LX, vectorX);
                    NumberUtil.getBezierData(_loc_3.colorOffsetR, _loc_4.colorOffsetR, _loc_3.colorOffsetR + _loc_3.bezierVo.RY, _loc_4.colorOffsetR + _loc_4.bezierVo.LY, vectorR);
                    NumberUtil.getBezierData(_loc_3.colorOffsetG, _loc_4.colorOffsetG, _loc_3.colorOffsetG + _loc_3.bezierVo.RY, _loc_4.colorOffsetG + _loc_4.bezierVo.LY, vectorG);
                    NumberUtil.getBezierData(_loc_3.colorOffsetB, _loc_4.colorOffsetB, _loc_3.colorOffsetB + _loc_3.bezierVo.RY, _loc_4.colorOffsetB + _loc_4.bezierVo.LY, vectorB);
                    _loc_9 = param1;
                    while (_loc_9 < _loc_8)
                    {
                        
                        if (!_cache[_loc_9])
                        {
                            _loc_15 = NumberUtil.getBezierTimeAndValue(_loc_9, vectorX, null);
                            _loc_16 = _loc_15 * _loc_15;
                            _loc_17 = _loc_16 * _loc_15;
                            _loc_10 = new ColorKeyFrame(_loc_9, -1, null);
                            _loc_10.colorOffsetR = vectorR.x * _loc_17 + vectorR.y * _loc_16 + vectorR.z * _loc_15 + vectorR.w;
                            _loc_10.colorOffsetG = vectorG.x * _loc_17 + vectorG.y * _loc_16 + vectorG.z * _loc_15 + vectorG.w;
                            _loc_10.colorOffsetB = vectorB.x * _loc_17 + vectorB.y * _loc_16 + vectorB.z * _loc_15 + vectorB.w;
                            _cache[_loc_9] = _loc_10;
                        }
                        _loc_9++;
                    }
                }
            }
            return;
        }// end function

        override public function parserKeyFrames(param1:Object) : void
        {
            var _loc_3:ColorKeyFrame = null;
            var _loc_5:Object = null;
            var _loc_6:Boolean = false;
            var _loc_7:BezierVo = null;
            var _loc_8:int = 0;
            var _loc_9:Object = null;
            var _loc_10:Number = NaN;
            var _loc_2:* = param1.length;
            var _loc_4:int = 0;
            while (_loc_4 < _loc_2)
            {
                
                _loc_5 = param1[_loc_4];
                _loc_6 = _loc_5.isLineTween == null ? (true) : (_loc_5.isLineTween);
                _loc_7 = new BezierVo(_loc_5.LX, _loc_5.LY, _loc_5.RX, _loc_5.RY, _loc_6);
                _loc_8 = _loc_5.index;
                _loc_9 = _loc_5.attributes;
                if (_loc_9 is Array)
                {
                    _loc_10 = _loc_9[0].value;
                }
                else
                {
                    _loc_10 = Number(_loc_9);
                }
                var _loc_11:int = 0;
                _loc_10 = 0;
                _loc_3 = new ColorKeyFrame(_loc_8, _loc_10, _loc_7);
                _keyframes.push(_loc_3);
                _loc_4++;
            }
            _keyframes.sortOn("frame", Array.NUMERIC);
            this.setPlayLable(this.defaultLable);
            this.defaultLable.change(0, _keyframes[(_loc_2 - 1)].frame);
            _cache.length = 0;
            return;
        }// end function

        override public function editKeyFrame(param1:Object, param2:int, param3:String, param4, param5:BezierVo) : Object
        {
            var _loc_8:ColorKeyFrame = null;
            var _loc_6:* = param1 is String ? (this.getLabel(String(param1))) : (Label3D(param1));
            if (_loc_6.to < param2)
            {
                _loc_6.change(_loc_6.from, param2);
            }
            var _loc_7:* = getKeyFramePlaceByFrameIndex(param2, this._keyframes);
            if (_loc_7 == -1)
            {
                _loc_8 = new ColorKeyFrame(param2, param4, param5);
                _keyframes.push(_loc_8);
                _keyframes.sortOn("frame", Array.NUMERIC);
            }
            else
            {
                _loc_8 = _keyframes[_loc_7];
                _loc_8.bezierVo = param5;
            }
            _loc_8.colorOffsetR = (param4 >> 16 & 255) / 255;
            _loc_8.colorOffsetG = (param4 >> 8 & 255) / 255;
            _loc_8.colorOffsetB = (param4 & 255) / 255;
            _cache.length = 0;
            return _loc_8;
        }// end function

    }
}
